/*
 * SoftwareSAR - 1.0
 */
package br.com.cpqd.ssar.mediador;

import br.com.cpqd.ssar.geradormalha.ControladorGeradorMalha;
import br.com.cpqd.ssar.gerenciador.ControladorGerenciador;
import br.com.cpqd.ssar.importadores.ControladorImportadores;
import br.com.cpqd.ssar.mediador.gui.ControladorJanelas;
import br.com.cpqd.ssar.posprocessamento.Visualizador;
import br.com.cpqd.ssar.processamento.ControladorSimuladores;
import br.com.cpqd.ssar.processamento.ControladorConfiguracoesProcessamento;
import br.com.cpqd.ssar.utilitarias.DominioComputacional;
import br.com.cpqd.ssar.utilitarias.FonteEletromagneticaSimulacao;
import br.com.cpqd.ssar.utilitarias.Geometria;
import br.com.cpqd.ssar.utilitarias.ListaFontesEletromagneticas;
import br.com.cpqd.ssar.utilitarias.ListaFontesEletromagneticasSimulacao;
import br.com.cpqd.ssar.utilitarias.Material;
import br.com.cpqd.ssar.utilitarias.Vertice;
import java.awt.Frame;
import java.io.File;
import java.io.IOException;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;

/**
 * Classe que Controla Todos os Serviços do Software
 * @author Rafael Buck
 * @version 1.5
 */
public class ControladorServicos implements RequisicaoServicos {

    /**
     * Controlador dos Diretórios e Nomes
     */
    private ControladorDiretorios controladorDiretorios;
    /**
     * Controlador de Janelas Principal
     */
    private ControladorJanelas controladorJanelas;
    /**
     * Controlador do Módulo Gerenciador
     */
    private ControladorGerenciador controladorGerenciador;
    /**
     * Controlador do Módulo Processamento
     */
    private ControladorSimuladores controladorSimuladores;
    /**
     * Controlador do Módulo Importadores
     */
    private ControladorImportadores controladorImportadores;
    /**
     * Controlador do Módulo Gerador de Malha
     */
    private ControladorGeradorMalha controladorGeradorMalha;
    /**
     * Controlador de Materiais
     */
    private ControladorMateriais controladorMateriais;
    /**
     * Controlador para Configurar a PML
     */
    private ControladorPML controladorPML;
    /**
     * Controlador para Salvar e Abrir Simulação
     */
    private ControladorAbrirSalvar controladorAbrirSalvar;
    /**
     * Controlador de Fontes Eletromagneticas
     */
    private ControladorFonteEletromagnetica controladorFonteEletromagnetica;
    /**
     * Controlador de Configuração do processamento para a geração dos arquivos 
     * utilizados pelo FDTD
     */
    private ControladorConfiguracoesProcessamento controladorConfiguracaoProcessamento;

    /**
     * Método Contrutor
     * @param controlador ControladorJanelas
     */
    public ControladorServicos(ControladorJanelas controlador) {
        controladorDiretorios = new ControladorDiretorios();
        controladorMateriais = new ControladorMateriais();

        controladorAbrirSalvar = new ControladorAbrirSalvar(controladorMateriais, controladorDiretorios);
        controladorConfiguracaoProcessamento = new ControladorConfiguracoesProcessamento();
        controladorPML = new ControladorPML();

        controladorFonteEletromagnetica = new ControladorFonteEletromagnetica();

        controladorJanelas = controlador;
        controladorJanelas.setControladorDiretorios(controladorDiretorios);
        controladorJanelas.setControladorMateriais(controladorMateriais);
        controladorGerenciador = new ControladorGerenciador(this);
        controladorJanelas.setJPanel(controladorGerenciador.obterPainel());

        controladorSimuladores = new ControladorSimuladores();
        controladorImportadores = new ControladorImportadores();
        controladorGeradorMalha = new ControladorGeradorMalha(this);
        controladorJanelas.setControladorServicos(this);
    }

    public boolean gerarMalhaFDTD(Geometria[] lista, Vertice max, Vertice min) {
        // ---- Chamada Antiga, com a mudança necessária a malha incluindo a 
        // regiao de PML a chamada seguinte é a correta.
        //
        // gerar malha

        Geometria dominio = new Geometria();
        dominio = controladorGerenciador.getDominioComputacional();
        int[] discretizar = new int[3];
        discretizar[0] = dominio.getAtributos().getDiscretizacaoX();
        discretizar[1] = dominio.getAtributos().getDiscretizacaoY();
        discretizar[2] = dominio.getAtributos().getDiscretizacaoZ();


        Vector pml = new Vector();
        pml = getCamadasPML();
        controladorGeradorMalha.setDimensoes(discretizar[0], discretizar[1], discretizar[2]);
        boolean resultado = controladorGeradorMalha.gerarMalhaFDTDcomPMLs(lista, max, min,
                Integer.valueOf(pml.get(0).toString()),
                Integer.valueOf(pml.get(1).toString()), Integer.valueOf(pml.get(2).toString()),
                Integer.valueOf(pml.get(3).toString()), Integer.valueOf(pml.get(4).toString()),
                Integer.valueOf(pml.get(5).toString()));
        //nxfPML, nyiPML, nyfPML, nziPML, nzfPML);
        // mostra a malha feita
        controladorGeradorMalha.exibirJanelaMalhaGerada();
        return resultado;
    }

    public boolean gerarMalhaFDTDcomPMLs(Geometria[] lista, Vertice max, Vertice min, int nxiPML, int nxfPML, int nyiPML, int nyfPML, int nziPML, int nzfPML) {
        // gera malha
        Geometria dominio = new Geometria();
        dominio = controladorGerenciador.getDominioComputacional();
        int[] discretizar = new int[3];
        discretizar[0] = dominio.getAtributos().getDiscretizacaoX();
        discretizar[1] = dominio.getAtributos().getDiscretizacaoY();
        discretizar[2] = dominio.getAtributos().getDiscretizacaoZ();

        controladorGeradorMalha.setDimensoes(discretizar[0], discretizar[1], discretizar[2]);
        boolean resultado = controladorGeradorMalha.gerarMalhaFDTDcomPMLs(lista, max, min, nxiPML, nxfPML, nyiPML, nyfPML, nziPML, nzfPML);
        // mostra a malha feita
        controladorGeradorMalha.exibirJanelaMalhaGerada();
        return resultado;
    }

    public Geometria importarMalha() {
        return controladorGeradorMalha.importarMalha();
    }

    public boolean configurarSimulacaoFDTD() {

        // ---------------------------------------------------------------------
        // ---------------------------------------------------------------------
        // Sequencia de passos de configuracao da simulacao para o processamento
        // com o metodo FDTD
        // 0 - Definir os arquivos de entrada e saida do FDTD    
        // 1 - Definicoes do dominio computacional
        // 2 - Definir a discretizacao do dominio (quantidade de células do FDTD)
        // 3 - Definir as camadas PML utilizadas na simulacao
        // 4 - Insere as fontes eletromagneticas na simulacao
        // 5 - Definindo os relatorios a serem gerados
        // 6 - Execução do processamento numérico com o FDTD
        // ---------------------------------------------------------------------
        // ---------------------------------------------------------------------

        // ---------------------------------------------------------------------
        //  0 - Definir os arquivos de entrada e saida do FDTD           
        // ---------------------------------------------------------------------
        controladorConfiguracaoProcessamento.setNomeArquivoEntradaFDTD(controladorDiretorios.obterNomeBaseEntradaFDTD());
        controladorConfiguracaoProcessamento.setNomeArquivoSaidaFDTD(controladorDiretorios.obterNomeBaseSaidaFDTD());

        // ---------------------------------------------------------------------
        // 1 - Definicoes do dominio computacional
        // ---------------------------------------------------------------------
        // Variaveis dessa etapa
        Vector discretizar = new Vector();
        Vector delta = new Vector();
        Vector pml = new Vector();
        float[] firstp = new float[3];
        float[] secondp = new float[3];
        Geometria dominio = new Geometria();

        // Retorna as configuracoes do dominio computacional do Gerenciador de simulacao
        dominio = controladorGerenciador.getDominioComputacional();

        // Definir os limites da cena de simulacao 
        Vertice max = new Vertice();
        Vertice min = new Vertice();
        Vertice[] vertices = new Vertice[2];
        min.setCoordenada(controladorGerenciador.getDominioComputacional().getAtributos().getFirsPoint());
        max.setCoordenada(controladorGerenciador.getDominioComputacional().getAtributos().getSecondPoint());
        vertices[0] = min;
        vertices[1] = max;
        controladorConfiguracaoProcessamento.setLimitesDominioFDTD(vertices);

        // Definir o valor dos Delta espaciais
        delta.add(dominio.getAtributos().getDx());
        delta.add(dominio.getAtributos().getDy());
        delta.add(dominio.getAtributos().getDz());
        controladorConfiguracaoProcessamento.setDeltaFDTD(delta);

        // ---------------------------------------------------------------------
        // 2 - Define as dimensoes de discretizacao (quantidade de celulas)
        // ---------------------------------------------------------------------
        discretizar.add(dominio.getAtributos().getDiscretizacaoX());
        discretizar.add(dominio.getAtributos().getDiscretizacaoY());
        discretizar.add(dominio.getAtributos().getDiscretizacaoZ());
        controladorConfiguracaoProcessamento.setDiscretizacaoDominioFDTD(discretizar);

        // ---------------------------------------------------------------------
        // 3 - Insere a quantidade de camadas PML utilizadas na simulacao, em
        // cada direção Cartesiana do dominio.
        // ---------------------------------------------------------------------
        pml.add(dominio.getAtributos().getPmlXi());
        pml.add(dominio.getAtributos().getPmlXf());
        pml.add(dominio.getAtributos().getPmlYi());
        pml.add(dominio.getAtributos().getPmlYf());
        pml.add(dominio.getAtributos().getPmlZi());
        pml.add(dominio.getAtributos().getPmlZf());
        controladorPML.setCamadas(pml);
        controladorPML.salvarConfiguracoesPML();
        controladorConfiguracaoProcessamento.setPml(pml);

        // ---------------------------------------------------------------------
        // 4 - Insere as fontes eletromagneticas na simulacao
        // ---------------------------------------------------------------------
        //controladorFonteEletromagnetica.setArquivoListaFontesSimulacao(controladorDiretorios.obterNomeScriptFontesSimulacao());
        controladorFonteEletromagnetica.setNomeArquivoFonteFDTD(controladorDiretorios.obterNomeArquivoConfiguracaoFontesEletromagneticasFDTD());

        ListaFontesEletromagneticasSimulacao listaFonteSimulacao = new ListaFontesEletromagneticasSimulacao();
        listaFonteSimulacao = controladorFonteEletromagnetica.getListaFonteEletromagneticaSimulacao();
        controladorConfiguracaoProcessamento.setListaFontesEletromagneticasSimulacao(listaFonteSimulacao);

        ListaFontesEletromagneticas listaFonte;
        try {
            listaFonte = new ListaFontesEletromagneticas();
            controladorConfiguracaoProcessamento.setListaFontesEletromagneticas(listaFonte);
        } catch (IOException ex) {
            Logger.getLogger(ControladorServicos.class.getName()).log(Level.SEVERE, null, ex);
        }

        // ---------------------------------------------------------------------
        // 5 - Gerar arquivo de relatorios
        // ---------------------------------------------------------------------
        Vector relatorios = controladorGerenciador.getTodosPreRelatorios();
        controladorConfiguracaoProcessamento.setRelatorios(relatorios);


        // ---------------------------------------------------------------------
        // 6 - Execução do processamento
        // ---------------------------------------------------------------------
        
        controladorSimuladores.setInputDatabaseFilename(controladorDiretorios.obterNomeBaseEntradaFDTD());
        controladorSimuladores.setOutputDatabaseFilename(controladorDiretorios.obterNomeBaseSaidaFDTD());
        controladorConfiguracaoProcessamento.setPassosTempo(dominio.getAtributos().getNSteps());
        controladorConfiguracaoProcessamento.configurarSimulacao();


        return true;
    }

    public boolean verificarArquivosEntradaFEM() {
        return controladorConfiguracaoProcessamento.verificaArquivosEntradaFEM();
    }

    public String getCaminhoProjeto() {
        return controladorDiretorios.getCaminhoProjeto();
    }

    @Override
    public String getCaminhoResultadosProjeto() {
        return controladorDiretorios.obterCaminhoResultados() + File.separator + "Resultados";

    }

    /**
     * 
     */
    @Override
    public void carregarProjeto() {
        Vector valor = new Vector();
        Vector pml = new Vector();
        Geometria dominio = new Geometria();

        controladorPML.setNomeArquivoPML(controladorDiretorios.obterNomeArquivoConfiguracaoPMLFDTD());
        pml = getCamadasPML();
        controladorAbrirSalvar.setParameterosAbrirProjeto(controladorDiretorios.obterNomeScriptGeometrias(), controladorDiretorios.obterNomeScriptRelatorios(), pml);
        valor = controladorAbrirSalvar.abrirProjeto(controladorImportadores);
        controladorGerenciador.inserirVectorListGeometry(valor);
        dominio = controladorAbrirSalvar.getDominioComputacional();

        if (dominio != null) {
            controladorGerenciador.setDominioComputacional(dominio);        // Quando abre o projeto ele atribui ao controlador de PML o nome base
        // do arquivo de configuracao da PML
        }


        // Inicialza a listagem de Fontes Eletromagneticas da Simulacao armazena
        // e repassa a arvore do Gerenciador
        ListaFontesEletromagneticasSimulacao listaFonteSimulacao = new ListaFontesEletromagneticasSimulacao();
        listaFonteSimulacao.setArquivoListaFontesSimulacao(controladorDiretorios.obterNomeScriptFontesSimulacao());
        listaFonteSimulacao.iniciarFontesEletromagneticasSimulacao();
        controladorGerenciador.carregarListaFontes(listaFonteSimulacao.getLista());
        
        controladorFonteEletromagnetica.iniciarListaFontesEletromagneticasSimulacao(listaFonteSimulacao);
        try {

            System.out.println("relatorio tamanho: " + controladorAbrirSalvar.abrirRelatorios().size());
            controladorGerenciador.addVectorPreRelatorios(controladorAbrirSalvar.abrirRelatorios());
           
        } catch (IOException ex) {
            Logger.getLogger(ControladorServicos.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * 
     */
    public void salvarProjeto() {
        Vector vectorGeo = new Vector();
        Geometria dominio = new Geometria();

        vectorGeo = controladorGerenciador.obterArvoreGeometria();
        dominio = controladorGerenciador.getDominioComputacional();
      
        if (dominio == null) {
            float[] firstPoint = new float[3];
            float[] secondPoint = new float[3];
            int[] discretizar = new int[3];
            int[] pml = new int[6];

            // ---- Atributos iniciais de configuracao do dominio computacional
            // Ponto onde se inicia a simulacao
            firstPoint[0] = -50;
            firstPoint[1] = -50;
            firstPoint[2] = -50;

            // Ponto de encerramento do dominio
            secondPoint[0] = 50;
            secondPoint[1] = 50;
            secondPoint[2] = 50;

            // Fator de discretizacao, ou seja, quantidade de células em cada direcao x, y e z
            discretizar[0] = 100;
            discretizar[1] = 100;
            discretizar[2] = 100;

            int nsteps = 16;

            // Quantidade de camadas pml em cada direcao x0, x1, y0, y1, z0, z1
            pml[0] = 10;
            pml[1] = 10;
            pml[2] = 10;
            pml[3] = 10;
            pml[4] = 10;
            pml[5] = 10;
            Vector pml2 = new Vector();
            for (int cont = 0; cont < 6; cont++) {
                pml2.add(pml[cont]);
            }
            controladorPML.setNomeArquivoPML(controladorDiretorios.obterNomeArquivoConfiguracaoPMLFDTD());
            controladorPML.setCamadas(pml2);
            controladorPML.salvarConfiguracoesPML();

            // Atribui um material padrao para validar o armazenamento do dominio computacional
            Material materialDefault = new Material(true);
            materialDefault = obterMaterial(1);         //ar


            dominio = new Geometria(0, "DominioComputacional", new DominioComputacional(firstPoint, secondPoint, firstPoint, 0, discretizar[0], discretizar[1], discretizar[2], pml[0], pml[1], pml[2], pml[3], pml[4], pml[5], controladorDiretorios.getUnidadeDimensional(), nsteps), true, true, materialDefault, 0.0f, 0.0f, 0.0f);
            // Atribuindo o domínio a Simulacao            
            controladorGerenciador.setDominioComputacional(dominio);

        }
        Vector relatorios = new Vector();
        relatorios = controladorGerenciador.getTodosPreRelatorios();

        controladorAbrirSalvar.setParametrosSalvarProjeto(vectorGeo, relatorios,dominio, controladorDiretorios.obterNomeScriptGeometrias(), controladorDiretorios.obterNomeScriptRelatorios());
        controladorAbrirSalvar.salvarProjeto();
        try {
            controladorAbrirSalvar.salvarRelatorio();
        } catch (IOException ex) {
            Logger.getLogger(ControladorServicos.class.getName()).log(Level.SEVERE, null, ex);
        }


        if (controladorFonteEletromagnetica.getArquivoListaFontesSimulacao() == null)//&&(controladorFonteEletromagnetica.sizeFontesSimulacao()<=0))            
        {
            controladorFonteEletromagnetica.setArquivoListaFontesSimulacao(controladorDiretorios.obterNomeScriptFontesSimulacao());
        }
        controladorFonteEletromagnetica.salvarFontesSimulacao();

        controladorPML.setNomeArquivoPML(controladorDiretorios.obterNomeArquivoConfiguracaoPMLFDTD());
        controladorPML.configurarPMLFDTD();
    }

    public void abrirProjeto() {
        controladorJanelas.abrirNovoProjeto();
    }

    public void novoProjeto() {
        controladorJanelas.criarNovoProjeto();
    }

    public void configurarPML() {
        controladorPML.callJanelaConfigurarPML(controladorPML);
    }

    public Geometria[] importarDXF() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public Geometria importarSTL() {

        return controladorImportadores.importarSTL(controladorGerenciador.getQuantidadeGeometrias());
    }

    public Geometria importarSTL(String nome, int id) {
        return controladorImportadores.importarSTL(nome, id);
    }

    public Geometria[] criarGeometria() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public Geometria[] editarGeometria(Geometria[] lista) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void exibirCartaSmith() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void exibirFilme2D(String fileNameMovie2d) {
        Visualizador v = new Visualizador("Filme 3D");
        v.exibirVideo2D(fileNameMovie2d);
    }

    @Override
    public void exibirFilme3D(String fileNameMovie3d) {
        Visualizador v = new Visualizador("Filme 3D");
        v.exibirVideo3D(fileNameMovie3d);
        //v.setVisible(true);
        //controladorGerenciador.addRelatorio(v);
    }

    @Override
    public void exibirGraficoCampo2D() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void exibirGraficoCampo3D() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void exibirGraficoFFT() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void exibirGraficoSAR2D() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void exibirGraficoSAR3D() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void exibirGraficoTempo(String fileName, String legendaX, String legendaY) {
        Visualizador v = new Visualizador("Gráfico Tempo");
        v.exibirGraficoTempo(fileName, legendaX, legendaY);
        v.setVisible(true);
        controladorGerenciador.addRelatorio(v);
    }

    /**
     * Simula FDTD 3D
     */
    public void simularFDTD() {
        if (controladorDiretorios.isProjetoGerado()) {
            //Seta Caminhos
            controladorSimuladores.setInputDatabaseFilename(controladorDiretorios.obterNomeBaseEntradaFDTD());
            controladorSimuladores.setOutputDatabaseFilename(controladorDiretorios.obterNomeBaseSaidaFDTD());
            // Executa Simulação do FDTD
            controladorSimuladores.simularFDTD();
        }
    }

    public ControladorJanelas getControladorJanelas() {
        return controladorJanelas;
    }

    public void setControladorJanelas(ControladorJanelas newControlador) {
        this.controladorJanelas = newControlador;
    }

    /**
     * Finaliza Processo Corrente
     */
    public void finalizarProcesso() {
        controladorSimuladores.finalizarProcesso();
    }

    /**
     * Retorna o Material Selecionado pelo Usuário
     * @return Material
     */
    public Material setMaterial() {
        return controladorJanelas.getMaterialSelecionado();
    }

    /**
     * Insere uma Fonte Eletromagnetica na Simulacao
     * @return fonte FonteEletromagneticaSimulacao
     */
    public FonteEletromagneticaSimulacao inserirFonteEletromagneticaSimulacao(float x, float y, float z) {
        Vector coordenadas = new Vector();
        coordenadas.addElement(x);
        coordenadas.addElement(y);
        coordenadas.addElement(z);
        controladorFonteEletromagnetica.setCoordenadas(coordenadas);
        FonteEletromagneticaSimulacao retorno = new FonteEletromagneticaSimulacao();
        retorno = controladorFonteEletromagnetica.callJanelaInserirFonteEletromagnetica(controladorFonteEletromagnetica.sizeFontesSimulacao());
        if (retorno != null) {
            controladorFonteEletromagnetica.setFonteEletromagneticaSimulacao(retorno);
            controladorFonteEletromagnetica.inserirFonteEletromagneticaSimulacao();
        }
        return retorno;
    }

    /**
     * Editar Fonte Eletromagnética Inserida na Simulcao
     */
    public void editarFonteEletromagneticaSimulacao(FonteEletromagneticaSimulacao fonte) {
//        controladorFonteEletromagnetica.setArquivoListaFontesSimulacao(controladorDiretorios.obterNomeScriptFontesSimulacao());
        controladorFonteEletromagnetica.callJanelaEditarFonteEletromagneticaSimulacao(controladorFonteEletromagnetica, fonte);
    }

    /*
     * Remover uma fonte Eletromagnetica Cadastrada para a Simulacao
     * @param fonte FonteEletromagneticaSimulacao
     */
    public boolean removerFonteEletromagneticaSimulacao(FonteEletromagneticaSimulacao fonte) {
//        controladorFonteEletromagnetica.setArquivoListaFontesSimulacao(controladorDiretorios.obterNomeScriptFontesSimulacao());
        return controladorFonteEletromagnetica.removerFonteEletromagneticaSimulacao(fonte);
    }

    /*
     * Abrir a Janela de Remoção de Fontes Eletromagnéticas do Usuário
     */
    public void removerFonteEletromagnetica() throws IOException {
        controladorFonteEletromagnetica.callJanelaRemoverFonteEletromagnetica();
    }

    public Vector getCamadasPML() {
        return controladorPML.getCamadasPML();
    }

    public Material obterMaterial(int idMaterial) {
        return controladorMateriais.getMaterial(idMaterial);
    }

    public String obterNomeArquivoMalhaFDTD() {
        return controladorDiretorios.obterNomeArquivoMalhaFDTD();
    }

    @Override
    public String obterNomeArquivoMateriaisFDTD() {
        return controladorDiretorios.obterNomeArquivoMateriaisFDTD();
    }

    public String obterNomeArquivoDeltasFDTD() {
        return controladorDiretorios.obterNomeArquivoDeltasFDTD();
    }

    @Override
    public String getUnidadeDimensional() {
        return controladorDiretorios.getUnidadeDimensional();
    }

    @Override
    public void setUnidadeDimensional(String unidadeDimensional) {
        controladorDiretorios.setUnidadeDimensional(unidadeDimensional);
    }

    /**
     * Não Implementado
     * @param opcao
     */
    @Override
    public void travarUnidadeDimensional(boolean opcao) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void reinicializarSistema() {
        controladorGerenciador = new ControladorGerenciador(this);
        controladorJanelas.setJPanel(controladorGerenciador.obterPainel());
    }

    @Override
    public void exibirMensagemInformacao(String mensagem) {
        JOptionPane.showMessageDialog(new Frame(), mensagem, "Mensagem de Informação", JOptionPane.INFORMATION_MESSAGE);
    }

    @Override
    public void exibirMensagemAlerta(String mensagem) {
        JOptionPane.showMessageDialog(new Frame(), mensagem, "Mensagem de Alerta", JOptionPane.WARNING_MESSAGE);
    }

    @Override
    public void exibirMensagemErro(String mensagem) {
        JOptionPane.showMessageDialog(new Frame(), mensagem, "Mensagem de Erro", JOptionPane.ERROR_MESSAGE);
    }

    @Override
    public int exibirMensagemEscolhaSimNao(String mensagem) {
        Object[] opcoes = {"      Sim      ", "      Não      "};
        return JOptionPane.showOptionDialog(new Frame(), mensagem, "Selecione uma Opção", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, opcoes, opcoes[0]);
    }

    @Override
    public int exibirMensagemEscolhaSimNaoCancelar(String mensagem) {
        Object[] opcoes = {"      Sim      ", "      Não      ", "    Cancelar    "};
        return JOptionPane.showOptionDialog(new Frame(), mensagem, "Selecione uma Opção", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, opcoes, opcoes[0]);
    }

    @Override
    public boolean simularFEMProcesso(String caminho) {
        return controladorSimuladores.simularFEMProcesso(caminho);
    }

    @Override
    public String getNomeProjeto() {
        return controladorDiretorios.getNomeProjeto();
    }

    @Override
    public void exibirGraficoAreaSAR(String fileName, String legendaX, String legendaY) {
        Visualizador v = new Visualizador("Área SSAR");
        v.exibirGraficoAreaSAR(fileName, legendaX, legendaY);
        v.setVisible(true);
        controladorGerenciador.addRelatorio(v);
    }

    @Override
    public void callJanelaRemoverFonteEletromagnetica() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

}

